### isArray


```ts
function isArray<A>(value: A | ReadonlyArray<unknown>): value is GuardArray<A>
```

```ts
G.isArray([1, 2, 3]) // → true
pipe(['hello', 'world'], G.isArray) // → true
```

### isBoolean


```ts
function isBoolean<A>(value: A | boolean): value is GuardValue<A, boolean>
```

```ts
G.isBoolean(false) // → true
pipe(true, G.isBoolean) // → true
```

### isDate


```ts
function isDate<A>(value: A): value is Extract<A, Date>
```

```ts
G.isDate(new Date()) // → true
pipe(new Date(), G.isDate) // → true
```

### isError


```ts
function isError<A>(value: A | Error): value is GuardValue<A, Error>
```

```ts
G.isError(new Error('oops!')) // → true
pipe(new Error('oops!'), G.isError) // → true
```

### isFunction


```ts
function isFunction<A>(value: A | Function): value is GuardValue<A, Function>
```

```ts
G.isFunction(F.ignore) // → true
pipe(F.ignore, G.isFunction) // → true
```

### isNot


```ts
function isNot<A, B extends A>(value: A, predicateFn: (value: A) => value is B): value is Exclude<A, B>
function isNot<A, B extends A>(predicateFn: (value: A) => value is B): (value: A) => value is Exclude<A, B>
function isNot<A>(value: A, predicateFn: (value: A) => any): boolean
function isNot<A>(predicateFn: (value: A) => any): (value: A) => boolean
```

```ts
// ⬇️ const isNotString = G.isNot(G.isString)
isNotString(0) // → true

pipe('ts-belt', G.isNot(G.isString)) // → false
```

### isNotNullable


```ts
function isNotNullable<A>(value: A): value is NonNullable<A>
```

```ts
G.isNotNullable('ts-belt') // → true
G.isNotNullable(null) // → false
pipe(0, G.isNotNullable) // → true
pipe(undefined, G.isNotNullable) // → false
```

### isNull


```ts
function isNull<A>(value: A | null | undefined): value is null
```

```ts
G.isNull(null) // → true
pipe(null, G.isNull) // → true
```

### isNullable


```ts
function isNullable<A>(value: A): value is Extract<A, null | undefined>
```

```ts
G.isNullable(null) // → true
pipe(undefined, G.isNullable) // → true
```

### isNumber


```ts
function isNumber<A>(value: A | number): value is GuardValue<A, number>
```

```ts
G.isNumber(3) // → true
pipe(3, G.isNumber) // → true
```

### isObject


```ts
function isObject<A>(value: A | object): value is GuardObject<A>
```

```ts
G.isObject({}) // → true
pipe({}, G.isObject) // → true
```

### isPromise


```ts
function isPromise<A>(value: A | Promise<unknown>): value is GuardPromise<A>
```

```ts
G.isPromise(Promise.resolve(1)) // → true
pipe(Promise.resolve(1), G.isPromise) // → true
```

### isString


```ts
function isString<A>(value: A | string): value is GuardValue<A, string>
```

```ts
G.isString('ts') // → true
pipe('belt', G.isString) // → true
```

### isUndefined


```ts
function isUndefined<A>(value: A | null | undefined): value is undefined
```

```ts
G.isUndefined(undefined) // → true
pipe(undefined, G.isUndefined) // → true
```